const express = require('express');
const { getDb, getAllQuery, getQuery } = require('../models/database');
const { triggerScan } = require('../services/scanner');
const { getFileMetadata, readFileContent, detectEncoding } = require('../services/splitter');
const path = require('path');
const { getLastScanCache, updateScanCache } = require('../models/database');
const fs = require('fs').promises;
const { scanDirectoryForNovels } = require('../services/scanner');

const router = express.Router();

// 请求日志中间件
const requestLogger = (req, res, next) => {
  const startTime = Date.now();
  const requestId = Math.random().toString(36).substring(2, 12);
  
  console.log(`[${new Date().toISOString()}] [${requestId}] 收到请求: ${req.method} ${req.originalUrl}`);
  console.log(`[${requestId}] 请求参数:`, {
    params: req.params,
    query: req.query,
    body: req.method === 'POST' || req.method === 'PUT' ? req.body : undefined
  });
  
  // 截获响应
  const originalSend = res.send;
  res.send = function(body) {
    const duration = Date.now() - startTime;
    
    // 如果是JSON响应，记录状态
    let responseLog = '';
    if (res.get('Content-Type')?.includes('application/json')) {
      try {
        const data = typeof body === 'string' ? JSON.parse(body) : body;
        // 截断长响应以避免日志太大
        const truncatedData = Array.isArray(data) 
          ? `数组，包含 ${data.length} 项` 
          : (typeof data === 'object' && data !== null)
            ? `对象，键: ${Object.keys(data).join(', ')}`
            : data;
            
        responseLog = `，响应: ${truncatedData}`;
      } catch (e) {
        responseLog = '，响应: [无法解析的JSON]';
      }
    }
    
    console.log(`[${new Date().toISOString()}] [${requestId}] 完成请求: ${req.method} ${req.originalUrl} - 状态: ${res.statusCode} - 耗时: ${duration}ms${responseLog}`);
    return originalSend.call(this, body);
  };
  
  // 监听错误
  const errorHandler = (err) => {
    console.error(`[${new Date().toISOString()}] [${requestId}] 请求错误: ${req.method} ${req.originalUrl}`, err);
  };
  
  res.on('error', errorHandler);
  req.on('error', errorHandler);
  
  next();
};

// 应用请求日志中间件
router.use(requestLogger);

// 获取所有小说列表
router.get('/novels', async (req, res) => {
  console.log(`开始获取小说列表...`);
  
  try {
    // 直接从数据库获取所有小说信息
    console.log(`从数据库查询小说信息...`);
    const novels = await getAllQuery(`
      SELECT *, ROUND(size / 2) as wordCount 
      FROM novels 
      ORDER BY name
    `);
    console.log(`查询到 ${novels.length} 本小说`);
    
    // 设置附加属性
    const novelsWithMetadata = novels.map(novel => ({
      ...novel,
      formattedSize: (novel.size / (1024 * 1024)).toFixed(2) + ' MB',
      encoding: 'gbk' // 默认编码
    }));
    
    console.log(`小说列表处理完成，返回 ${novelsWithMetadata.length} 条记录`);
    res.json(novelsWithMetadata);
  } catch (err) {
    console.error('获取小说列表失败:', err);
    return res.status(500).json({ error: '获取小说列表失败' });
  }
});

// 获取单本小说信息
router.get('/novels/:id', async (req, res) => {
  const id = req.params.id;
  
  console.log(`获取小说信息，ID: ${id}`);
  
  if (!id) {
    console.warn(`获取小说失败：无效的小说ID`);
    return res.status(400).json({ error: '无效的小说ID' });
  }
  
  try {
    // 从数据库获取小说信息
    const novel = await getQuery('SELECT *, ROUND(size / 2) as wordCount FROM novels WHERE id = ?', [id]);
    
    if (!novel) {
      console.warn(`小说ID ${id} 不存在`);
      return res.status(404).json({ error: '小说不存在' });
    }
    
    console.log(`找到小说: "${novel.name}", 路径: ${novel.path}`);
    
    // 添加附加信息
    const novelWithMetadata = {
      ...novel,
      formattedSize: (novel.size / (1024 * 1024)).toFixed(2) + ' MB',
      encoding: 'gbk', // 默认编码
      modified: novel.modified
    };
    
    console.log(`返回小说 "${novel.name}" 的完整信息`);
    res.json(novelWithMetadata);
  } catch (err) {
    console.error(`获取小说ID ${id} 失败:`, err);
    return res.status(500).json({ error: '获取小说失败' });
  }
});

// 获取小说内容
router.get('/novels/:id/content', async (req, res) => {
  const { id } = req.params;
  const { encoding, binary } = req.query;
  
  // 验证ID
  if (!id || isNaN(parseInt(id))) {
    return res.status(400).json({ error: '无效的小说ID' });
  }
  
  try {
    // 获取小说信息
    const { id } = req.params;
    const { encoding, binary } = req.query;
    const useBinaryMode = binary === 'true';
    
    console.log(`[novel.routes] 获取小说内容: ID=${id}, 编码=${encoding || '自动检测'}, 二进制模式=${useBinaryMode}`);
    
    // 验证ID是否有效
    if (!id || isNaN(parseInt(id))) {
      return res.status(400).json({ error: '无效的小说ID' });
    }
    
    // 查询小说信息
    const query = 'SELECT path, name FROM novels WHERE id = ?';
    const novel = await getQuery(query, [id]);
    
    if (!novel) {
      return res.status(404).json({ error: '找不到指定的小说' });
    }
    
    const filePath = novel.path;
    
    // 验证文件是否存在
    try {
      await fs.access(filePath);
    } catch (err) {
      console.error(`[novel.routes] 文件不存在: ${filePath}`, err);
      return res.status(404).json({ error: '小说文件不存在或无法访问', details: err.message });
    }
    
    // 二进制模式：直接发送文件
    if (useBinaryMode) {
      console.log(`[novel.routes] 使用二进制模式发送文件: ${filePath}`);
      
      try {
        const fileData = await fs.readFile(filePath);
        console.log(`[novel.routes] 文件已读取，大小: ${(fileData.length / (1024 * 1024)).toFixed(2)}MB`);
        
        // 设置响应头
        res.setHeader('Content-Type', 'application/octet-stream');
        res.setHeader('Content-Disposition', `attachment; filename=${encodeURIComponent(novel.name)}`);
        
        // 发送二进制数据
        return res.send(fileData);
      } catch (err) {
        console.error(`[novel.routes] 读取二进制文件失败: ${filePath}`, err);
        return res.status(500).json({ error: '读取文件失败', details: err.message });
      }
    }
    
    // 文本模式：检测编码并读取内容
    try {
      // 检测编码或使用强制指定的编码
      let detectedEncoding;
      if (encoding && ['utf8', 'utf-8', 'gbk', 'gb2312', 'utf16le', 'utf16be'].includes(encoding.toLowerCase())) {
        detectedEncoding = encoding.toLowerCase();
        console.log(`[novel.routes] 使用强制指定的编码: ${detectedEncoding}`);
      } else {
        detectedEncoding = await detectEncoding(filePath);
      }
      
      // 读取文件内容
      const content = await readFileContent(filePath, detectedEncoding);
      
      // 更新小说的最后打开时间
      // const updateQuery = 'UPDATE novels SET lastOpenedAt = ? WHERE id = ?';
      // await getQuery(updateQuery, [new Date().toISOString(), id]);
      
      console.log(`[novel.routes] 成功获取小说内容，大小: ${(content.length / 1024).toFixed(2)}KB`);
      res.json({ content, encoding: detectedEncoding });
      
    } catch (err) {
      console.error(`[novel.routes] 读取小说内容失败: ${filePath}`, err);
      res.status(500).json({ error: '读取小说内容失败', details: err.message });
    }
  } catch (err) {
    console.error('[novel.routes] 处理请求失败', err);
    res.status(500).json({ error: '处理请求失败', details: err.message });
  }
});

// 获取小说章节列表
router.get('/novels/:id/chapters', (req, res) => {
  const id = req.params.id;
  
  console.log(`获取小说章节列表，ID: ${id}`);
  
  // 这里添加章节列表功能，可以扫描文件提取章节
  // 暂时返回错误，表示功能未实现
  return res.status(501).json({ error: '章节列表功能未实现' });
});

// 触发扫描
router.post('/novels/scan', async (req, res) => {
  console.log(`[scanner] 触发小说扫描请求...`);
  const { force = false } = req.body; // 是否强制重新扫描
  
  try {
    // 如果不是强制扫描，先检查缓存
    if (!force) {
      const cache = await getLastScanCache();
      if (cache) {
        const lastScanTime = new Date(cache.last_scan_time);
        const currentTime = new Date();
        const timeDiffMinutes = (currentTime - lastScanTime) / (1000 * 60);
        
        // 如果缓存时间不超过30分钟，直接返回缓存结果
        if (timeDiffMinutes < 30) {
          console.log(`[scanner] 使用缓存的扫描结果，上次扫描: ${cache.last_scan_time}, 小说数: ${cache.novels_count}`);
          return res.json({ 
            message: '返回缓存结果', 
            count: cache.novels_count,
            cached: true,
            lastScan: cache.last_scan_time
          });
        }
        console.log(`[scanner] 缓存已过期 (${timeDiffMinutes.toFixed(2)}分钟), 执行新扫描`);
      } else {
        console.log(`[scanner] 未找到有效缓存，执行完整扫描`);
      }
    } else {
      console.log(`[scanner] 强制扫描模式，忽略缓存`);
    }
    
    // 执行扫描
    const NOVELS_PATH = process.env.NOVELS_PATH || path.join(__dirname, '../../../novels');
    console.log(`[scanner] 开始扫描目录: ${NOVELS_PATH}`);
    
    const count = await triggerScan(NOVELS_PATH);
    console.log(`[scanner] 扫描完成，发现 ${count} 本小说`);
    
    // 更新缓存
    await updateScanCache(count);
    
    res.json({ 
      message: '扫描成功', 
      count,
      cached: false,
      lastScan: new Date().toISOString()
    });
  } catch (err) {
    console.error('[scanner] 触发扫描失败:', err);
    res.status(500).json({ error: '触发扫描失败' });
  }
});

// 更新阅读进度
router.post('/novels/:id/progress', async (req, res) => {
  try {
    const { id } = req.params;
    const { lastPosition } = req.body;
    
    // 验证ID是否有效
    if (!id || isNaN(parseInt(id))) {
      return res.status(400).json({ error: '无效的小说ID' });
    }
    
    // 验证进度数据
    if (lastPosition === undefined) {
      return res.status(400).json({ error: '无效的进度数据' });
    }
    
    // 更新小说的阅读进度
    const updateQuery = 'UPDATE novels SET lastPosition = ? WHERE id = ?';
    await getQuery(updateQuery, [JSON.stringify(lastPosition), id]);
    
    console.log(`[novel.routes] 已更新小说阅读进度: ID=${id}, 位置=${JSON.stringify(lastPosition)}`);
    res.json({ success: true });
  } catch (err) {
    console.error('[novel.routes] 更新阅读进度失败', err);
    res.status(500).json({ error: '更新阅读进度失败', details: err.message });
  }
});

// 扫描目录中的小说
router.get('/scan', async (req, res) => {
  try {
    const { fresh } = req.query;
    
    // 检查是否已有缓存结果且不是强制刷新
    const cacheFile = path.join(__dirname, '../../cache/novels-scan.json');
    
    if (fresh !== 'true') {
      try {
        const cacheStats = await fs.stat(cacheFile);
        const cacheAge = Date.now() - cacheStats.mtime.getTime();
        
        // 如果缓存不超过1小时，直接返回缓存结果
        if (cacheAge < 60 * 60 * 1000) {
          console.log('[novel.routes] 使用缓存的扫描结果');
          const cacheData = await fs.readFile(cacheFile, 'utf8');
          return res.json(JSON.parse(cacheData));
        }
      } catch (err) {
        console.log('[novel.routes] 无法读取缓存或缓存过期，进行新的扫描');
      }
    }
    
    // 获取配置
    const configQuery = 'SELECT value FROM settings WHERE key = ?';
    const configResult = await getQuery(configQuery, ['novelFolders']);
    
    if (!configResult || !configResult.value) {
      return res.status(400).json({ error: '未配置小说文件夹' });
    }
    
    const folders = JSON.parse(configResult.value);
    
    if (!folders || !Array.isArray(folders) || folders.length === 0) {
      return res.status(400).json({ error: '小说文件夹列表为空' });
    }
    
    // 构建扫描结果
    const result = {
      folders,
      files: [],
      errors: []
    };
    
    // 扫描每个文件夹
    for (const folder of folders) {
      try {
        console.log(`[novel.routes] 扫描文件夹: ${folder}`);
        
        // 检查文件夹是否存在
        try {
          await fs.access(folder);
        } catch (err) {
          console.error(`[novel.routes] 文件夹不存在或无法访问: ${folder}`, err);
          result.errors.push(`文件夹不存在或无法访问: ${folder}`);
          continue;
        }
        
        // 递归扫描文件夹中的所有 .txt 文件
        const scanFolder = async (dir, depth = 0) => {
          if (depth > 3) return; // 限制递归深度
          
          const items = await fs.readdir(dir, { withFileTypes: true });
          
          for (const item of items) {
            const itemPath = path.join(dir, item.name);
            
            if (item.isDirectory()) {
              await scanFolder(itemPath, depth + 1);
            } else if (item.isFile() && item.name.toLowerCase().endsWith('.txt')) {
              try {
                const stats = await fs.stat(itemPath);
                
                // 仅添加大于10KB的文件
                if (stats.size > 10 * 1024) {
                  result.files.push({
                    fileName: item.name,
                    filePath: itemPath,
                    fileSize: stats.size,
                    formattedSize: (stats.size / (1024 * 1024)).toFixed(2) + ' MB',
                    modifiedAt: stats.mtime.toISOString()
                  });
                }
              } catch (err) {
                console.warn(`[novel.routes] 无法读取文件信息: ${itemPath}`, err);
              }
            }
          }
        };
        
        await scanFolder(folder);
        
      } catch (err) {
        console.error(`[novel.routes] 扫描文件夹失败: ${folder}`, err);
        result.errors.push(`扫描文件夹失败: ${folder}, 错误: ${err.message}`);
      }
    }
    
    console.log(`[novel.routes] 扫描完成，找到 ${result.files.length} 个文件`);
    
    // 保存缓存
    try {
      // 确保缓存目录存在
      const cacheDir = path.dirname(cacheFile);
      await fs.mkdir(cacheDir, { recursive: true });
      
      // 保存结果到缓存
      await fs.writeFile(cacheFile, JSON.stringify(result), 'utf8');
      console.log('[novel.routes] 扫描结果已缓存');
    } catch (err) {
      console.warn('[novel.routes] 无法缓存扫描结果', err);
    }
    
    res.json(result);
  } catch (err) {
    console.error('[novel.routes] 扫描小说失败', err);
    res.status(500).json({ error: '扫描小说失败', details: err.message });
  }
});

module.exports = router;